import { MastraClient } from '@mastra/client-js';

/**
 * 游戏客户端
 * 基于mastra-client调用游戏管理Agent，替代传统的REST API调用
 */
export class GameClient {
  private client: MastraClient;

  constructor(baseUrl: string = 'http://localhost:4111') {
    this.client = new MastraClient({
      baseUrl,
    });
  }

  /**
   * 开始新游戏
   * @param difficulty 游戏难度
   * @param theme 案件主题
   * @param suspectCount 嫌疑人数量
   * @returns 游戏数据和状态
   */
  async startNewGame(
    difficulty: 'easy' | 'normal' | 'hard',
    theme?: string,
    suspectCount: number = 3
  ) {
    try {
      console.log('通过Agent开始新游戏:', { difficulty, theme, suspectCount });
      
      const result = await this.client.agent.run({
        agentId: 'gameManagerAgent',
        messages: [
          {
            role: 'user',
            content: `请开始一个新的推理游戏。
            
            游戏配置：
            - 难度：${difficulty}
            - 主题：${theme || '随机'}
            - 嫌疑人数量：${suspectCount}
            
            请使用 game-management 工具执行 start_game 操作。`
          }
        ]
      });

      console.log('Agent响应:', result);
      
      // 从工具调用结果中提取游戏数据
      if (result.toolCalls && result.toolCalls.length > 0) {
        const gameData = result.toolCalls[0].result;
        return {
          success: true,
          data: gameData.data,
          gameState: gameData.gameState,
          message: gameData.message
        };
      }

      return {
        success: false,
        message: '游戏开始失败：Agent未返回有效结果',
        error: 'NO_TOOL_CALLS'
      };

    } catch (error) {
      console.error('开始新游戏失败:', error);
      return {
        success: false,
        message: `开始游戏失败: ${error instanceof Error ? error.message : '未知错误'}`,
        error: 'CLIENT_ERROR'
      };
    }
  }

  /**
   * 与嫌疑人对话
   * @param gameId 游戏ID
   * @param suspectId 嫌疑人ID
   * @param question 问题
   * @param conversationHistory 对话历史
   * @returns 嫌疑人回应
   */
  async chatWithSuspect(
    gameId: string,
    suspectId: string,
    question: string,
    conversationHistory: any[] = []
  ) {
    try {
      console.log('通过Agent与嫌疑人对话:', { gameId, suspectId, question });
      
      const result = await this.client.agent.run({
        agentId: 'gameManagerAgent',
        messages: [
          {
            role: 'user',
            content: `请处理与嫌疑人的对话。
            
            对话信息：
            - 游戏ID：${gameId}
            - 嫌疑人ID：${suspectId}
            - 问题：${question}
            - 对话历史：${JSON.stringify(conversationHistory)}
            
            请使用 game-management 工具执行 chat_with_suspect 操作。`
          }
        ]
      });

      console.log('Agent响应:', result);
      
      if (result.toolCalls && result.toolCalls.length > 0) {
        const chatData = result.toolCalls[0].result;
        return {
          success: true,
          data: chatData.data,
          message: chatData.message
        };
      }

      return {
        success: false,
        message: '对话失败：Agent未返回有效结果',
        error: 'NO_TOOL_CALLS'
      };

    } catch (error) {
      console.error('对话失败:', error);
      return {
        success: false,
        message: `对话失败: ${error instanceof Error ? error.message : '未知错误'}`,
        error: 'CLIENT_ERROR'
      };
    }
  }

  /**
   * 提交推理结果
   * @param gameId 游戏ID
   * @param deduction 推理结果
   * @returns 评估结果
   */
  async submitDeduction(gameId: string, deduction: {
    culpritId: string;
    reasoning: string;
    evidence: string[];
  }) {
    try {
      console.log('通过Agent提交推理结果:', { gameId, deduction });
      
      const result = await this.client.agent.run({
        agentId: 'gameManagerAgent',
        messages: [
          {
            role: 'user',
            content: `请评估玩家的推理结果。
            
            推理信息：
            - 游戏ID：${gameId}
            - 选择的真凶：${deduction.culpritId}
            - 推理过程：${deduction.reasoning}
            - 支持证据：${deduction.evidence.join(', ')}
            
            请使用 game-management 工具执行 submit_deduction 操作。`
          }
        ]
      });

      console.log('Agent响应:', result);
      
      if (result.toolCalls && result.toolCalls.length > 0) {
        const evaluationData = result.toolCalls[0].result;
        return {
          success: true,
          data: evaluationData.data,
          message: evaluationData.message
        };
      }

      return {
        success: false,
        message: '推理评估失败：Agent未返回有效结果',
        error: 'NO_TOOL_CALLS'
      };

    } catch (error) {
      console.error('提交推理失败:', error);
      return {
        success: false,
        message: `提交推理失败: ${error instanceof Error ? error.message : '未知错误'}`,
        error: 'CLIENT_ERROR'
      };
    }
  }

  /**
   * 获取游戏状态
   * @param gameId 游戏ID
   * @returns 游戏状态
   */
  async getGameStatus(gameId: string) {
    try {
      console.log('通过Agent获取游戏状态:', gameId);
      
      const result = await this.client.agent.run({
        agentId: 'gameManagerAgent',
        messages: [
          {
            role: 'user',
            content: `请获取游戏状态。
            
            游戏ID：${gameId}
            
            请使用 game-management 工具执行 get_game_status 操作。`
          }
        ]
      });

      console.log('Agent响应:', result);
      
      if (result.toolCalls && result.toolCalls.length > 0) {
        const statusData = result.toolCalls[0].result;
        return {
          success: true,
          data: statusData.data,
          gameState: statusData.gameState,
          message: statusData.message
        };
      }

      return {
        success: false,
        message: '获取状态失败：Agent未返回有效结果',
        error: 'NO_TOOL_CALLS'
      };

    } catch (error) {
      console.error('获取游戏状态失败:', error);
      return {
        success: false,
        message: `获取状态失败: ${error instanceof Error ? error.message : '未知错误'}`,
        error: 'CLIENT_ERROR'
      };
    }
  }

  /**
   * 直接调用游戏管理Agent
   * @param action 操作类型
   * @param params 操作参数
   * @returns Agent响应
   */
  async callGameManager(action: string, params: any) {
    try {
      console.log('直接调用游戏管理Agent:', { action, params });
      
      const result = await this.client.agent.run({
        agentId: 'gameManagerAgent',
        messages: [
          {
            role: 'user',
            content: `请执行游戏操作：${action}
            
            操作参数：${JSON.stringify(params, null, 2)}
            
            请使用 game-management 工具来处理这个请求。`
          }
        ]
      });

      return result;

    } catch (error) {
      console.error('调用游戏管理Agent失败:', error);
      throw error;
    }
  }
}

/**
 * 创建游戏客户端实例
 */
export function createGameClient(baseUrl?: string) {
  return new GameClient(baseUrl);
}

/**
 * 默认游戏客户端实例
 */
export const gameClient = new GameClient();
